package com.lmk.mkcc.service.impl;

import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.lmk.mkcc.constants.RedisCouresTypeConstants;
import com.lmk.mkcc.domain.CourseType;
import com.lmk.mkcc.enums.GlobalErrorCode;
import com.lmk.mkcc.mapper.CourseTypeMapper;
import com.lmk.mkcc.service.ICourseTypeService;
import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import com.lmk.mkcc.util.AssertUtil;
import com.lmk.mkcc.vo.CrumbsVo;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

/**
 * <p>
 * 课程目录 服务实现类
 * </p>
 *
 * @author kun
 * @since 2022-09-30
 */
@Service
@Slf4j
public class CourseTypeServiceImpl extends ServiceImpl<CourseTypeMapper, CourseType> implements ICourseTypeService {
    @Autowired
    private RedisTemplate<Object,Object> redisTemplate;

    @Override
    @Cacheable(cacheNames = RedisCouresTypeConstants.COURSE_TYPE_TREE_DATA_CACHE_NAMES,key =RedisCouresTypeConstants.COURSE_TYPE_TREE_DATA_CACHE_KEY )
    public List<CourseType> getTreeData() {
        Object o = redisTemplate.opsForValue().get(RedisCouresTypeConstants.COURSE_TYPE_TREE_DATA_CACHE_NAMES);
        if (o !=null){
            log.info("从缓存中获取");
            return (List<CourseType>)o;
        }
        log.info("从数据库中获取");
        return tree();
    }

    // 面包屑功能的实现
    @Override
    public List<CrumbsVo> getcrumbs(Long courseTypeId) {
        // 根据课程类型id查询出对应类型
        CourseType courseType = selectById(courseTypeId);
        AssertUtil.isNotNull(courseType, GlobalErrorCode.COURSE_TYPE_ERROR);
        // 获取当前课程类型的path，
        String path = courseType.getPath();
        AssertUtil.isNotNull(path, GlobalErrorCode.COURSE_TYPE_PATH_ERROR);
        // 将获取到的path根据.来进行分割,获取一个coursetypeid的集合
        String[] split = path.split("\\.");
        // 创建一个集合用来装对应的课程类型
        ArrayList<CrumbsVo> typelist = new ArrayList<>();
        for (String coursetypeid : split) {
            CourseType type = selectById(coursetypeid);
            CrumbsVo crumbsVo = new CrumbsVo();
            crumbsVo.setOwnerProductType(type);
            // 根据当前类型的pid来获取所有相同pid的课程类型的集合
            Long pid = type.getPid();
            EntityWrapper<CourseType> wrapper = new EntityWrapper<>();
            wrapper.eq("pid",pid);
            List<CourseType> courseTypes = selectList(wrapper);
            crumbsVo.setOtherProductTypes(courseTypes);
            // 将crumbsVo对象放入集合
            typelist.add(crumbsVo);
        }
        return typelist;
    }


    // 将方法抽取出来
    private List<CourseType> tree() {
        // 查询课程类型所有数据
        List<CourseType> list = selectList(null);
        // 定义一个map集合
        HashMap<Long, CourseType> map = new HashMap<>();
        for (CourseType courseType : list) {
            map.put(courseType.getId(),courseType);
        }
        List<CourseType> treedate = new ArrayList<>();
        for (CourseType courseType : list) {
            if(courseType.getPid() == null) {//顶级部门
                treedate.add(courseType);
            }else{
                if (courseType.getPid()==null || courseType.getPid().intValue()==0){
                    treedate.add(courseType);
                }else {
                    Long pid = courseType.getPid();
                    CourseType parentcourseType = map.get(pid);
                    parentcourseType.getChildren().add(courseType);
                }

            }
        }
        // redisTemplate.opsForValue().set(RedisCouresTypeConstants.COURSE_TYPE_TREE_DATA,treedate);
        return treedate;
    }

    @Override
    @CacheEvict(cacheNames = RedisCouresTypeConstants.COURSE_TYPE_TREE_DATA_CACHE_NAMES,key =RedisCouresTypeConstants.COURSE_TYPE_TREE_DATA_CACHE_KEY )
    public boolean insert(CourseType entity) {
        return super.insert(entity);
    }

    @Override
    @CacheEvict(cacheNames = RedisCouresTypeConstants.COURSE_TYPE_TREE_DATA_CACHE_NAMES,key =RedisCouresTypeConstants.COURSE_TYPE_TREE_DATA_CACHE_KEY )
    public boolean deleteById(Serializable id) {
        return super.deleteById(id);
    }

    @Override
    @CacheEvict(cacheNames = RedisCouresTypeConstants.COURSE_TYPE_TREE_DATA_CACHE_NAMES,key =RedisCouresTypeConstants.COURSE_TYPE_TREE_DATA_CACHE_KEY )
    public boolean updateById(CourseType entity) {
        return super.updateById(entity);

    }
}
